23 research outputs found
A Metric for Linear Temporal Logic
We propose a measure and a metric on the sets of infinite traces generated by
a set of atomic propositions. To compute these quantities, we first map
properties to subsets of the real numbers and then take the Lebesgue measure of
the resulting sets. We analyze how this measure is computed for Linear Temporal
Logic (LTL) formulas. An implementation for computing the measure of bounded
LTL properties is provided and explained. This implementation leverages SAT
model counting and effects independence checks on subexpressions to compute the
measure and metric compositionally
Modal Reactors
Complex software systems often feature distinct modes of operation, each
designed to handle a particular scenario that may require the system to respond
in a certain way. Breaking down system behavior into mutually exclusive modes
and discrete transitions between modes is a commonly used strategy to reduce
implementation complexity and promote code readability. However, such
capabilities often come in the form of self-contained domain specific languages
or language-specific frameworks. The work in this paper aims to bring the
advantages of modal models to mainstream programming languages, by following
the polyglot coordination approach of Lingua Franca (LF), in which verbatim
target code (e.g., C, C++, Python, Typescript, or Rust) is encapsulated in
composable reactive components called reactors. Reactors can form a dataflow
network, are triggered by timed as well as sporadic events, execute
concurrently, and can be distributed across nodes on a network.
With modal models in LF, we introduce a lean extension to the concept of
reactors that enables the coordination of reactive tasks based on modes of
operation. The implementation of modal reactors outlined in this paper
generalizes to any LF-supported language with only modest modifications to the
generic runtime system
LNCS
Responsiveness—the requirement that every request to a system be eventually handled—is one of the fundamental liveness properties of a reactive system. Average response time is a quantitative measure for the responsiveness requirement used commonly in performance evaluation. We show how average response time can be computed on state-transition graphs, on Markov chains, and on game graphs. In all three cases, we give polynomial-time algorithms
Consistency vs. Availability in Distributed Real-Time Systems
In distributed applications, Brewer's CAP theorem tells us that when networks
become partitioned (P), one must give up either consistency (C) or availability
(A). Consistency is agreement on the values of shared variables; availability
is the ability to respond to reads and writes accessing those shared variables.
Availability is a real-time property whereas consistency is a logical property.
We have extended the CAP theorem to relate quantitative measures of these two
properties to quantitative measures of communication and computation latency
(L), obtaining a relation called the CAL theorem that is linear in a max-plus
algebra. This paper shows how to use the CAL theorem in various ways to help
design real-time systems. We develop a methodology for systematically trading
off availability and consistency in application-specific ways and to guide the
system designer when putting functionality in end devices, in edge computers,
or in the cloud. We build on the Lingua Franca coordination language to provide
system designers with concrete analysis and design tools to make the required
tradeoffs in deployable software.Comment: 12 pages. arXiv admin note: text overlap with arXiv:2109.0777
Debugging and Verification Tools for LINGUA FRANCA in GEMOC Studio
International audienceLINGUA FRANCA (LF) is a polyglot coordination language designed for the composition of concurrent, timesensitive, and potentially distributed reactive components called reactors. The LF coordination layer facilitates the use of target languages (e.g., C, C++, Python, TypeScript) to realize the program logic, where each target language requires a separate runtime implementation that must correctly implement the reactor semantics. Verifying the correctness of runtime implementations is not a trivial task, and is currently done on the basis of regression testing. To provide a more formal verification tool for existing and future target runtimes, as well as to help verify properties of LF programs, we recruit the use of GEMOC Studio-an Eclipse-based workbench for the development, integration, and use of heterogeneous executable modeling languages. We present an operational model for LF, realized in GEMOC Studio, that is primed to interact with a rich set of analysis and verification tools. Our instrumentation provides the ability to navigate the execution of LF programs using an omniscient debugger with graphical model animation; to check assertions in particular execution runs, or exhaustively, using a model checker; and to validate or debug traces obtained from arbitrary LF runtime environments
Beyond the Threaded Programming Model on Real-Time Operating Systems
The use of a real-time operating system (RTOS) raises the abstraction level for embedded systems design when compared to traditional bare-metal programming, resulting in simpler and more reusable application code. Modern RTOSes for resource-constrained platforms, like Zephyr and FreeRTOS, also offer threading support, but this kind of shared memory concurrency is a poor fit for expressing the reactive and interactive behaviors that are common in embedded systems. To address this, alternative concurrency models like the actor model or communicating sequential processes have been proposed. While those alternatives enable reactive design patterns, they fail to deliver determinism and do not address timing. This makes it difficult to verify that implemented behavior is as intended and impossible to specify timing constraints in a portable way. This makes it hard to create reusable library components out of common embedded design patterns, forcing developers to keep reinventing the wheel for each application and each platform. In this paper, we introduce the embedded target of Lingua Franca (LF) as a means to move beyond the threaded programming model provided by RTOSes and improve the state of the art in embedded programming. LF is based on the reactor model of computation, which is reactive, deterministic, and timed, providing a means to express concurrency and timing in a platform-independent way. We compare the performance of LF versus threaded C code - both running on Zephyr - in terms of response time, timing precision, throughput, and memory footprint